home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 2: CDPD 1 / Almathera Ten on Ten - Disc 2: CDPD 1.iso / pd / 201-225 / 217 / stevie / dos.c < prev    next >
C/C++ Source or Header  |  1995-03-13  |  4KB  |  221 lines
  1. /*
  2.  * DOS System-dependent routines.
  3.  *
  4.  * System-specific code for MS-DOS. This has been tested with
  5.  * MSDOS 3.3 on an AT. Also, the console driver "nansi.sys" is
  6.  * required.
  7.  *
  8.  */
  9.  
  10. #include <dos.h>
  11. #include "stevie.h"
  12.  
  13. /*
  14.  * inchar() - get a character from the keyboard
  15.  */
  16. int
  17. inchar()
  18. {
  19.     int             c;
  20.  
  21.     for (;; beep()) {        /* loop until we get a valid character */
  22.  
  23.     flushbuf();        /* flush any pending output */
  24.  
  25.     switch (c = getch()) {
  26.       case 0x1e:
  27.         return K_CGRAVE;
  28.       case 0:        /* special key */
  29.         if (State != NORMAL) {
  30.         c = getch();    /* throw away next char */
  31.         continue;    /* and loop for another char */
  32.         }
  33.         switch (c = getch()) {
  34.           case 0x50:
  35.         return K_DARROW;
  36.           case 0x48:
  37.         return K_UARROW;
  38.           case 0x4b:
  39.         return K_LARROW;
  40.           case 0x4d:
  41.         return K_RARROW;
  42.           case 0x52:
  43.         return K_INSERT;
  44.           case 0x47:
  45.         stuffReadbuff("1G");
  46.         return -1;
  47.           case 0x4f:
  48.         stuffReadbuff("G");
  49.         return -1;
  50.           case 0x51:
  51.         stuffReadbuff(mkstr(CTRL('F')));
  52.         return -1;
  53.           case 0x49:
  54.         stuffReadbuff(mkstr(CTRL('B')));
  55.         return -1;
  56.         /*
  57.          * Hard-code some useful function key macros. 
  58.          */
  59.           case 0x3b:    /* F1 */
  60.         stuffReadbuff(":p\n");
  61.         return -1;
  62.           case 0x54:    /* SF1 */
  63.         stuffReadbuff(":p!\n");
  64.         return -1;
  65.           case 0x3c:    /* F2 */
  66.         stuffReadbuff(":n\n");
  67.         return -1;
  68.           case 0x55:    /* SF2 */
  69.         stuffReadbuff(":n!\n");
  70.         return -1;
  71.           case 0x3d:    /* F3 */
  72.         stuffReadbuff(":e #\n");
  73.         return -1;
  74.           case 0x3e:    /* F4 */
  75.         stuffReadbuff(":rew\n");
  76.         return -1;
  77.           case 0x57:    /* SF4 */
  78.         stuffReadbuff(":rew!\n");
  79.         return -1;
  80.           case 0x3f:    /* F5 */
  81.         stuffReadbuff("[[");
  82.         return -1;
  83.           case 0x40:    /* F6 */
  84.         stuffReadbuff("]]");
  85.         return -1;
  86.           case 0x41:    /* F7 */
  87.         stuffReadbuff("<<");
  88.         return -1;
  89.           case 0x42:    /* F8 */
  90.         stuffReadbuff(">>");
  91.         return -1;
  92.           case 0x43:    /* F9 */
  93.         stuffReadbuff(":x\n");
  94.         return -1;
  95.           case 0x44:    /* F10 */
  96.         stuffReadbuff(":help\n");
  97.         return -1;
  98.           default:
  99.         break;
  100.         }
  101.         break;
  102.  
  103.       default:
  104.         return c;
  105.     }
  106.     }
  107. }
  108.  
  109. #define BSIZE   2048
  110. static char     outbuf[BSIZE];
  111. static int      bpos = 0;
  112.  
  113. flushbuf()
  114. {
  115.     if (bpos != 0)
  116.     write(1, outbuf, bpos);
  117.     bpos = 0;
  118. }
  119.  
  120. /*
  121.  * Macro to output a character. Used within this file for speed.
  122.  */
  123. #define outone(c)       outbuf[bpos++] = c; if (bpos >= BSIZE) flushbuf()
  124.  
  125. /*
  126.  * Function version for use outside this file.
  127.  */
  128. void
  129. outchar(c)
  130.     register char   c;
  131. {
  132.     outbuf[bpos++] = c;
  133.     if (bpos >= BSIZE)
  134.     flushbuf();
  135. }
  136.  
  137. static char     cell[2] = {0, 7};
  138.  
  139. /*
  140.  * outstr(s) - write a string to the console
  141.  */
  142. void
  143. outstr(s)
  144.     register char  *s;
  145. {
  146.     while (*s) {
  147.     outone(*s++);
  148.     }
  149. }
  150.  
  151. void
  152. beep()
  153. {
  154.     if (RedrawingDisabled)
  155.     return;
  156.  
  157.     outone('\007');
  158. }
  159.  
  160. void
  161. sleep(n)
  162.     int             n;
  163. {
  164.     /*
  165.      * Should do something reasonable here. 
  166.      */
  167. }
  168.  
  169. void
  170. delay()
  171. {
  172.     long            l;
  173.  
  174.     flushbuf();
  175.     /*
  176.      * Should do something better here... 
  177.      */
  178.     for (l = 0; l < 5000; l++);
  179. }
  180.  
  181. void
  182. windinit()
  183. {
  184.     Columns = 80;
  185.     P(P_LI) = Rows = 25;
  186. }
  187.  
  188. void
  189. windexit(r)
  190.     int             r;
  191. {
  192.     flushbuf();
  193.     exit(r);
  194. }
  195.  
  196. void
  197. windgoto(r, c)
  198.     register int    r, c;
  199. {
  200.     union REGS      rr;
  201.  
  202.     flushbuf();
  203.     rr.h.dh = r;
  204.     rr.h.dl = c;
  205.     rr.x.bx = 0;
  206.     rr.x.ax = 0x0200;
  207.     int86(0x10, &rr, &rr);
  208. }
  209.  
  210. FILE           *
  211. fopenb(fname, mode)
  212.     char           *fname;
  213.     char           *mode;
  214. {
  215.     FILE           *fopen();
  216.     char            modestr[16];
  217.  
  218.     sprintf(modestr, "%sb", mode);
  219.     return fopen(fname, modestr);
  220. }
  221.